Giga Games 1/Giga Games.iso/net/usenet/volume8/tinymud/part04

Internet Message Format | 1989-12-31 | 33.5 KB

Path: uunet!wyse!mips!zaphod.mps.ohio-state.edu!usc!cs.utexas.edu!rice!uw-beaver!zephyr.ens.tek.com!tekred!saab!billr
From: [e-mail] (Bill Randle)
Newsgroups: comp.sources.games
Subject: v08i083:  tinymud - user-extendible multi-user adventure game, Part04/04
Message-ID: <[e-mail]>
Date: 20 Jan 90 03:16:12 GMT
Sender: [e-mail]
Lines: 1261
Approved: [e-mail]

Submitted-by: [e-mail]
Posting-number: Volume 8, Issue 83
Archive-name: tinymud/Part04



#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 4 (of 4)."
# Contents:  Makefile config.h copyright.h dump.c help.c help.txt
#   match.h paths.c player.c predicates.c restart-cmu sanity-check.c
#   small.db.README stringutil.c utils.c
# Wrapped by billr@saab on Fri Jan 19 19:14:31 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'Makefile' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'Makefile'\"
else
echo shar: Extracting \"'Makefile'\" \(3022 characters\)
sed "s/^X//" >'Makefile' <<'END_OF_FILE'
X#
X# Whatever you put in for $(CC) must be able to grok ANSI C.
X#
XCC=gcc
XOPTIM= -O -g -pipe -W -Wreturn-type -Wunused -Wcomment -Wwrite-strings
X#
X# To log failed commands (HUH's) to stderr, include -DLOG_FAILED_COMMANDS
X# To restricted object-creating commands to users with the BUILDER bit,
X#   include -DRESTRICTED_BUILDING
X# To log all commands, include -DLOG_COMMANDS
X#
XDEFS= -DLOG_FAILED_COMMANDS
XCFLAGS= $(OPTIM) $(DEFS)
X
X# Everything except interface.c --- allows for multiple interfaces
XCFILES= create.c game.c help.c look.c match.c move.c player.c predicates.c \
X    rob.c set.c speech.c stringutil.c utils.c wiz.c db.c game.c
X
X# .o versions of above
XOFILES= create.o game.o help.o look.o match.o move.o player.o predicates.o \
X    rob.o set.o speech.o stringutil.o utils.o wiz.o db.o
X
X# Files in the standard distribution
XDISTFILES= $(CFILES) config.h db.h externs.h interface.h match.h \
X    interface.c dump.c sanity-check.c extract.c paths.c \
X    help.txt small.db minimal.db restart-cmu README small.db.README \
X    Makefile copyright.h
X
XDESTDIR= /usr/asp/tinymud
X
XOUTFILES= netmud dump paths sanity-check extract TAGS
X
Xall: extract sanity-check dump paths netmud TAGS
X
XTAGS: *.c *.h
X    etags *.c *.h
X
Xnetmud: interface.o $(OFILES)
X    -mv -f netmud netmud~
X    $(CC) $(CFLAGS) -o netmud interface.o $(OFILES)
X
Xdump: dump.o utils.o db.o
X    -rm -f dump
X    $(CC) $(CFLAGS) -o dump dump.o utils.o db.o
X
Xsanity-check: sanity-check.o utils.o db.o
X    -rm -f sanity-check
X    $(CC) $(CFLAGS) -o sanity-check sanity-check.o utils.o db.o
X
Xextract: extract.o utils.o db.o
X    -rm -f extract
X    $(CC) $(CFLAGS) -o extract extract.o utils.o db.o
X
Xpaths: paths.o db.o
X    -rm -f paths
X    $(CC) $(CFLAGS) -o paths paths.o db.o
X
Xclean:
X    -rm -f *.o a.out core gmon.out $(OUTFILES)
X
Xdist.tar.Z: $(DISTFILES)
X    tar cvf - $(DISTFILES) | compress -c > dist.tar.Z.NEW
X    mv dist.tar.Z.NEW dist.tar.Z
X
X# DO NOT REMOVE THIS LINE OR CHANGE ANYTHING AFTER IT #
Xcreate.o: create.c db.h config.h interface.h externs.h
Xdb.o: db.c db.h
Xdump.o: dump.c db.h
Xextract.o: extract.c db.h
Xfix.o: fix.c db.h config.h
Xgame.o: game.c db.h config.h interface.h match.h externs.h
Xhelp.o: help.c db.h config.h interface.h externs.h
Xinterface.o: interface.c db.h interface.h config.h
Xjanitor.o: janitor.c db.h config.h interface.h externs.h
Xlook.o: look.c db.h config.h interface.h match.h externs.h
Xmatch.o: match.c db.h config.h match.h
Xmove.o: move.c db.h config.h interface.h match.h externs.h
Xold.o: old.c
Xpaths.o: paths.c db.h config.h
Xplayer.o: player.c db.h config.h interface.h externs.h
Xpredicates.o: predicates.c db.h interface.h config.h externs.h
Xrob.o: rob.c db.h config.h interface.h match.h externs.h
Xsanity-check.o: sanity-check.c db.h config.h
Xset.o: set.c db.h config.h match.h interface.h externs.h
Xspeech.o: speech.c db.h interface.h match.h config.h externs.h
Xstringutil.o: stringutil.c externs.h
Xtestmain.o: testmain.c db.h interface.h
Xutils.o: utils.c db.h
Xwiz.o: wiz.c db.h interface.h match.h externs.h
Xconfig.h:
Xdb.h:
Xexterns.h: db.h
Xinterface.h: db.h
Xmatch.h: db.h
END_OF_FILE
if test 3022 -ne `wc -c <'Makefile'`; then
    echo shar: \"'Makefile'\" unpacked with wrong size!
fi
# end of 'Makefile'
fi
if test -f 'config.h' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'config.h'\"
else
echo shar: Extracting \"'config.h'\" \(1981 characters\)
sed "s/^X//" >'config.h' <<'END_OF_FILE'
X#include "copyright.h"
X
X/* room number of player start location */
X#define PLAYER_START 0
X
X/* minimum cost to create various things */
X#define OBJECT_COST 10
X#define EXIT_COST 1
X#define LINK_COST 1
X#define ROOM_COST 10
X
X/* cost to do a scan */
X#define LOOKUP_COST 1
X
X/* magic cookies */
X#define NOT_TOKEN '!'
X#define LOOKUP_TOKEN '*'
X#define NUMBER_TOKEN '#'
X
X/* magic command cookies */
X#define SAY_TOKEN '"'
X#define POSE_TOKEN ':'
X
X/* amount of object endowment, based on cost */
X#define MAX_OBJECT_ENDOWMENT 100
X#define OBJECT_ENDOWMENT(cost) (((cost)-5)/5)
X
X/* amount at which temple stops being so profitable */
X#define MAX_PENNIES 10000
X
X/* penny generation parameters */
X#define PENNY_RATE 10        /* 1/chance of getting a penny per room */
X
X/* costs of kill command */
X#define KILL_BASE_COST 100    /* prob = expenditure/KILL_BASE_COST */
X#define KILL_MIN_COST 10
X#define KILL_BONUS 50        /* paid to victim */
X
X/* delimeter for lists of exit aliases */
X#define EXIT_DELIMITER ';'
X
X/* timing stuff */
X#define DUMP_INTERVAL 3600    /* seconds between dumps */
X#define COMMAND_TIME_MSEC 250    /* time slice length in milliseconds */
X#define COMMAND_BURST_SIZE 250    /* commands allowed per user in a burst */
X#define COMMANDS_PER_TIME 1    /* commands per time slice after burst */
X
X/* maximum amount of queued output */
X#define MAX_OUTPUT 16384
X
X#define TINYPORT 4201
X#define WELCOME_MESSAGE "Welcome to TinyMUD\nTo connect to your existing character, enter \"connect name password\"\nTo create a new character, enter \"create name password\"\nUse the news command to get up-to-date news on program changes.\n\nYou can disconnect using the QUIT command, which must be capitalized as shown.\n\nUse the WHO command to find out who is currently active.\n\n"
X
X#define LEAVE_MESSAGE "\n***Disconnected***\n"
X
X#define QUIT_COMMAND "QUIT"
X#define WHO_COMMAND "WHO"
X#define PREFIX_COMMAND "OUTPUTPREFIX"
X#define SUFFIX_COMMAND "OUTPUTSUFFIX"
X
X#define HELP_FILE "help.txt"
X
X#define NEWS_FILE "news.txt"
END_OF_FILE
if test 1981 -ne `wc -c <'config.h'`; then
    echo shar: \"'config.h'\" unpacked with wrong size!
fi
# end of 'config.h'
fi
if test -f 'copyright.h' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'copyright.h'\"
else
echo shar: Extracting \"'copyright.h'\" \(1391 characters\)
sed "s/^X//" >'copyright.h' <<'END_OF_FILE'
X/* -*-C-*-
X
XCopyright (c) 1989 by David Applegate, James Aspnes, and Bennet Yee.
X
XThis material was developed by the above-mentioned authors.
XPermission to copy this software, to redistribute it, and to use it
Xfor any purpose is granted, subject to the following restrictions and
Xunderstandings.
X
X1. Any copy made of this software must include this copyright notice
Xin full.
X
X2. Users of this software agree to make their best efforts (a) to
Xreturn to the above-mentioned authors any improvements or extensions
Xthat they make, so that these may be included in future releases; and
X(b) to inform the authors of noteworthy uses of this software.
X
X3. All materials developed as a consequence of the use of this
Xsoftware shall duly acknowledge such use, in accordance with the usual
Xstandards of acknowledging credit in academic research.
X
X4. The authors have made no warrantee or representation that the
Xoperation of this software will be error-free, and the authors are
Xunder no obligation to provide any services, by way of maintenance,
Xupdate, or otherwise.
X
X5. In conjunction with products arising from the use of this material,
Xthere shall be no use of the names of the authors, of Carnegie-Mellon
XUniversity, nor of any adaptation thereof in any advertising,
Xpromotional, or sales literature without prior written consent from
Xthe authors and Carnegie-Mellon University in each case. */
X
END_OF_FILE
if test 1391 -ne `wc -c <'copyright.h'`; then
    echo shar: \"'copyright.h'\" unpacked with wrong size!
fi
# end of 'copyright.h'
fi
if test -f 'dump.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'dump.c'\"
else
echo shar: Extracting \"'dump.c'\" \(2923 characters\)
sed "s/^X//" >'dump.c' <<'END_OF_FILE'
X#include "copyright.h"
X
X#include <stdio.h>
X
X#include "db.h"
X
Xvoid main(int argc, char **argv)
X{
X    struct object *o;
X    dbref owner;
X    dbref thing;
X
X    if(argc < 1) {
X    fprintf(stderr, "Usage: %s [owner]\n", *argv);
X    exit(1);
X    }
X
X    if(argc >= 2) {
X    owner = atol(argv[1]);
X    } else {
X    owner = NOTHING;
X    }
X
X    if(db_read(stdin) < 0) {
X    fprintf(stderr, "%s: bad input\n", argv[0]);
X    exit(5);
X    }
X
X    for(o = db; o < db+db_top; o++) {
X    /* don't show exits separately */
X    if((o->flags & TYPE_MASK) == TYPE_EXIT) continue;
X
X    /* don't show it if it isn't owned by the right player */
X    if(owner != NOTHING && o->owner != owner) continue;
X
X    printf("#%d: %s [%s] at %s(%d) Pennies: %d Type: ",
X           o - db, o->name, db[o->owner].name,
X           getname(o->location),
X           o->location,
X           o->pennies);
X    switch(o->flags & TYPE_MASK) {
X      case TYPE_ROOM:
X        printf("Room");
X        break;
X      case TYPE_EXIT:
X        printf("Exit");
X        break;
X      case TYPE_THING:
X        printf("Thing");
X        break;
X      case TYPE_PLAYER:
X        printf("Player");
X        break;
X      default:
X        printf("***UNKNOWN TYPE***");
X        break;
X    }
X
X    /* handle flags */
X    putchar(' ');
X    if(o->flags & ~TYPE_MASK) {
X        printf("Flags: ");
X        if(o->flags & LINK_OK) printf("LINK_OK ");
X        if(o->flags & DARK) printf("DARK ");
X        if(o->flags & STICKY) printf("STICKY ");
X        if(o->flags & WIZARD) printf("WIZARD ");
X        if(o->flags & TEMPLE) printf("TEMPLE ");
X#ifdef RESTRICTED_BUILDING
X        if(o->flags & BUILDER) printf("BUILDER ");
X#endif /* RESTRICTED_BUILDING */
X    }
X    putchar('\n');
X
X    if(o->key != NOTHING) printf("KEY: %c%s\n",
X                     o->flags & ANTILOCK ? '!' : ' ',
X                     getname(o->key));
X    if(o->description) {
X        puts("Description:");
X        puts(o->description);
X    }
X    if(o->succ_message) {
X        puts("Success Message:");
X        puts(o->succ_message);
X    }
X    if(o->fail_message) {
X        puts("Fail Message:");
X        puts(o->fail_message);
X    }
X    if(o->ofail) {
X        puts("Other Fail Message:");
X        puts(o->ofail);
X    }
X    if(o->osuccess) {
X        puts("Other Success Message:");
X        puts(o->osuccess);
X    }
X    if(o->contents != NOTHING) {
X        puts("Contents:");
X        DOLIST(thing, o->contents) {
X        /* dump thing description */
X        printf(" %s(%d)\n", db[thing].name, thing);
X        }
X    }
X    if(o->exits != NOTHING) {
X        if((o->flags & TYPE_MASK) == TYPE_ROOM) {
X        puts("Exits:");
X        DOLIST(thing, o->exits) {
X            printf(" %s", getname(thing));
X            if(db[thing].key != NOTHING) {
X            printf(" KEY: %c%s(%d)",
X                   db[thing].flags & ANTILOCK ? '!' : ' ',
X                   getname(db[thing].key),
X                   db[thing].key);
X            }
X            if(db[thing].location != NOTHING) {
X            printf(" => %s(%d)\n",
X                   getname(db[thing].location),
X                   db[thing].location);
X            } else {
X            puts(" ***OPEN***");
X            }
X        }
X        } else {
X        printf("Home: %s(%d)\n", getname(o->exits), o->exits);
X        }
X    }
X    putchar('\n');
X    }
X
X    exit(0);
X}
END_OF_FILE
if test 2923 -ne `wc -c <'dump.c'`; then
    echo shar: \"'dump.c'\" unpacked with wrong size!
fi
# end of 'dump.c'
fi
if test -f 'help.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help.c'\"
else
echo shar: Extracting \"'help.c'\" \(745 characters\)
sed "s/^X//" >'help.c' <<'END_OF_FILE'
X#include "copyright.h"
X
X/* commands for giving help */
X
X#include "db.h"
X#include "config.h"
X#include "interface.h"
X#include "externs.h"
X
Xvoid spit_file(dbref player, const char *filename)
X{
X    FILE *f;
X    char buf[BUFFER_LEN];
X    char *p;
X
X    if((f = fopen(filename, "r")) == NULL) {
X    sprintf(buf, "Sorry, %s is broken.  Management has been notified.",
X        filename);
X    notify(player, buf);
X    fputs("spit_file:", stderr);
X    perror(filename);
X    } else {
X    while(fgets(buf, sizeof buf, f)) {
X        for(p = buf; *p; p++) if(*p == '\n') {
X        *p = '\0';
X        break;
X        }
X        notify(player, buf);
X    }
X    fclose(f);
X    }
X}
X
Xvoid do_help(dbref player)
X{
X    spit_file(player, HELP_FILE);
X}
X
Xvoid do_news(dbref player)
X{
X    spit_file(player, NEWS_FILE);
X}
X
END_OF_FILE
if test 745 -ne `wc -c <'help.c'`; then
    echo shar: \"'help.c'\" unpacked with wrong size!
fi
# end of 'help.c'
fi
if test -f 'help.txt' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'help.txt'\"
else
echo shar: Extracting \"'help.txt'\" \(976 characters\)
sed "s/^X//" >'help.txt' <<'END_OF_FILE'
XThis is TinyMUD version 1.3, a user-extendible, multi-user adventure game.
XBasic commands:
X move/go <direction>
X get/take <thing>; drop/throw <thing>
X look; look <thing>; look <direction>
X say <message>
X rob <player>; give <player> = <number of pennies>; kill <player>
X inventory
X help
X news
X @describe me = <description>
X @password <oldpassword>=<newpassword>
X page <player> --- tell player that you are looking for them (cost 1 penny)
X gripe <message> --- Complain to the management.
X home --- go home
XOther commands are available for extending the universe.  Many of
Xthese commands cost pennies, which you can obtain in a number of ways.
XFull names of exits can be used in place of a go or move command.  The
Xnames "me" and "here" are special; me means the current player, and
Xhere means the current player's location.
XMore information is available in the reference section of the Library,
Xnorth of the Temple.
XRemember, no matter how bad it gets, you can always go home.
END_OF_FILE
if test 976 -ne `wc -c <'help.txt'`; then
    echo shar: \"'help.txt'\" unpacked with wrong size!
fi
# end of 'help.txt'
fi
if test -f 'match.h' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'match.h'\"
else
echo shar: Extracting \"'match.h'\" \(1359 characters\)
sed "s/^X//" >'match.h' <<'END_OF_FILE'
X#include "copyright.h"
X
X#include "db.h"
X
X/* match functions */
X/* Usage: init_match(player, name, type); match_this(); match_that(); ... */
X/* Then get value from match_result() */
X
X/* initialize matcher */
Xextern void init_match(dbref player, const char *name, int type);
Xextern void init_match_check_keys(dbref player, const char *name, int type);
X
X/* match (LOOKUP_TOKEN)player */
Xextern void match_player(void);
X
X/* match (NUMBER_TOKEN)number */
Xextern void match_absolute(void);
X
X/* match "me" */
Xextern void match_me(void);
X
X/* match "here" */
Xextern void match_here(void);
X
X/* match something player is carrying */
Xextern void match_possession(void);
X
X/* match something in the same room as player */
Xextern void match_neighbor(void);
X
X/* match an exit from player's room */
Xextern void match_exit(void);
X
X/* all of the above, except only Wizards do match_absolute and match_player */
Xextern void match_everything(void);
X
X/* return match results */
Xextern dbref match_result(void); /* returns AMBIGUOUS for multiple inexacts */
Xextern dbref last_match_result(void); /* returns last result */
X
X#define NOMATCH_MESSAGE "I don't see that here."
X#define AMBIGUOUS_MESSAGE "I don't know which one you mean!"
X
Xextern dbref noisy_match_result(void); /* wrapper for match_result */
X                /* noisily notifies player */
X                /* returns matched object or NOTHING */
END_OF_FILE
if test 1359 -ne `wc -c <'match.h'`; then
    echo shar: \"'match.h'\" unpacked with wrong size!
fi
# end of 'match.h'
fi
if test -f 'paths.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'paths.c'\"
else
echo shar: Extracting \"'paths.c'\" \(3573 characters\)
sed "s/^X//" >'paths.c' <<'END_OF_FILE'
X#include "copyright.h"
X
X#include <stdio.h>
X
X#include "db.h"
X#include "config.h"
X
X/* Compute shortest path to each room */
X/* Locks cost extra */
X#define INFINITY 2148575    /* MAXINT or thereabouts */
X#define LOCK_COST 10000        /* extra cost for a lock */
X
X/* This code blasts a lot of fields in the database, so */
X/* you don't ever want to write it back out afterwards. */
X
X/* Where things get stored: */
X/* cost to get here gets put in pennies */
X/* location is the previous room that gets you here */
X/* next is the next room in the search queue */
X/* key non-zero means already queued */
X/* contents is previous exit that gets you here */
X
X/* this should be a priority queue, but we're cheap */
Xdbref search_queue_head = NOTHING;
Xdbref search_queue_tail = NOTHING;
X
Xvoid queue_room(dbref room)
X{
X    if(db[room].key) return;
X
X    if(search_queue_tail == NOTHING) {
X    search_queue_head = room;
X    } else {
X    db[search_queue_tail].next = room;
X    }
X    search_queue_tail = room;
X    db[room].next = NOTHING;
X    db[room].key = 1;
X}
X
Xdbref dequeue_room()
X{
X    dbref room;
X
X    if((room = search_queue_head) == NOTHING) return NOTHING;
X    if((search_queue_head = db[room].next) == NOTHING) {
X    search_queue_tail = NOTHING;
X    }
X    db[room].next = NOTHING;
X    db[room].key = 0;
X
X    return room;
X}
X
Xvoid find_paths()
X{
X    dbref room;
X    dbref exit;
X    dbref mycost;        /* dbref[room].pennies */
X    dbref cost;            /* mycost + cost to use exit */
X    dbref dest;            /* exit destination */
X
X    while((room = dequeue_room()) != NOTHING) {
X    /* get first one */
X
X    /* check its exits */
X    mycost = db[room].pennies;
X    DOLIST(exit, db[room].exits) {
X        if((dest = db[exit].location) < 0) continue;
X        cost = mycost + 1;
X        if(db[exit].key != NOTHING) {
X        if(!(db[exit].flags & ANTILOCK)
X           && Typeof(db[exit].key) != TYPE_THING) {
X            continue;    /* we can't get it */
X        } else {
X            cost += LOCK_COST;
X        }
X        }
X        if(cost < db[dest].pennies) {
X        /* it's cheaper, set and queue it */
X        db[dest].pennies = cost;
X        db[dest].location = room;
X        db[dest].contents = exit;
X        queue_room(dest);
X        }
X    }
X    }
X}
X
Xvoid compute_paths(dbref start)
X{
X    dbref room;
X
X    /* clear out all fields we use */
X    for(room = 0; room < db_top; room++) {
X    if(Typeof(room) == TYPE_ROOM) {
X        db[room].location = db[room].next = db[room].contents = NOTHING;
X        db[room].pennies = INFINITY;
X        db[room].key = 0;
X    }
X    }
X
X    /* set up start */
X    db[start].pennies = 0;
X    queue_room(start);
X
X    find_paths();
X}
X
Xvoid print_path(dbref room)
X{
X    dbref prev;
X    dbref exit;
X    dbref key;
X
X    if((prev = db[room].location) != NOTHING) {
X    print_path(prev);
X    exit = db[room].contents;
X    if((key = db[exit].key) != NOTHING) {
X        printf("LOCKED[%s(%d)] ", db[key].name, key);
X    }
X    printf("%s => %s\n", db[exit].name, db[room].name);
X    }
X}
X
Xvoid print_paths()
X{
X    dbref room;
X
X    for(room = 0; room < db_top; room++) {
X    if(Typeof(room) == TYPE_ROOM) {
X        printf("%s(%d)[%s]: ",
X           db[room].name, room, db[db[room].owner].name);
X        if(db[room].pennies == INFINITY) {
X        puts("UNREACHABLE");
X        } else {
X        printf("%d + %d locks\n",
X               db[room].pennies % LOCK_COST,
X               db[room].pennies / LOCK_COST);
X        }
X        print_path(room);
X        putchar('\n');
X    }
X    }
X}
X
Xvoid main(int argc, char **argv)
X{
X    dbref start = 0;
X
X    if(argc >= 2) {
X    start = atol(argv[2]);
X    } else {
X    start = PLAYER_START;
X    }
X
X    if(db_read(stdin) < 0) {
X    fprintf(stderr, "%s: bad input\n", argv[0]);
X    exit(5);
X    }
X
X    compute_paths(start);
X    print_paths();
X
X    exit(0);
X}
END_OF_FILE
if test 3573 -ne `wc -c <'paths.c'`; then
    echo shar: \"'paths.c'\" unpacked with wrong size!
fi
# end of 'paths.c'
fi
if test -f 'player.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'player.c'\"
else
echo shar: Extracting \"'player.c'\" \(1556 characters\)
sed "s/^X//" >'player.c' <<'END_OF_FILE'
X#include "copyright.h"
X
X#include "db.h"
X#include "config.h"
X#include "interface.h"
X#include "externs.h"
X
X/* don't use this, it's expensive */
X/* maybe soon we'll put in a hash table */
Xdbref lookup_player(const char *name)
X{
X    dbref i;
X
X    for(i = 0; i < db_top; i++) {
X    if(Typeof(i) == TYPE_PLAYER
X       && db[i].name && !string_compare(db[i].name, name)) return i;
X    }
X    return NOTHING;
X}
X
Xdbref connect_player(const char *name, const char *password)
X{
X    dbref player;
X
X    if((player = lookup_player(name)) == NOTHING) return NOTHING;
X    if(db[player].password
X       && *db[player].password
X       &&strcmp(db[player].password, password)) return NOTHING;
X
X    return player;
X}
X
Xdbref create_player(const char *name, const char *password)
X{
X    dbref player;
X
X    if(!ok_player_name(name)) return NOTHING;
X
X    /* else he doesn't already exist, create him */
X    player = new_object();
X
X    /* initialize everything */
X    db[player].name = alloc_string(name);
X    db[player].location = PLAYER_START;
X    db[player].exits = PLAYER_START;    /* home */
X    db[player].owner = player;
X    db[player].flags = TYPE_PLAYER;
X    db[player].password = alloc_string(password);
X
X    /* link him to PLAYER_START */
X    PUSH(player, db[PLAYER_START].contents);
X
X    return player;
X}
X
Xvoid do_password(dbref player, const char *old, const char *newobj)
X{
X    if(strcmp(old, db[player].password)) {
X    notify(player, "Sorry");
X    } else {
X    free(db[player].password);
X    db[player].password = alloc_string(newobj);
X    notify(player, "Password changed.");
X    }
X}
END_OF_FILE
if test 1556 -ne `wc -c <'player.c'`; then
    echo shar: \"'player.c'\" unpacked with wrong size!
fi
# end of 'player.c'
fi
if test -f 'predicates.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'predicates.c'\"
else
echo shar: Extracting \"'predicates.c'\" \(2814 characters\)
sed "s/^X//" >'predicates.c' <<'END_OF_FILE'
X#include "copyright.h"
X
X/* Predicates for testing various conditions */
X
X#include <ctype.h>
X
X#include "db.h"
X#include "interface.h"
X#include "config.h"
X#include "externs.h"
X
Xint can_link_to(dbref who, dbref where)
X{
X    return(where >= 0
X       && where < db_top
X       && Typeof(where) == TYPE_ROOM
X       && (controls(who, where) || (db[where].flags & LINK_OK)));
X}
X
Xint could_doit(dbref player, dbref thing)
X{
X    dbref key;
X    int status;
X
X    if(Typeof(thing) != TYPE_ROOM && db[thing].location == NOTHING) return 0;
X    if((key = db[thing].key) == NOTHING) return 1;
X    status = (player == key || member(key, db[player].contents));
X    return((db[thing].flags & ANTILOCK) ? !status : status);
X}
X
Xint can_doit(dbref player, dbref thing, const char *default_fail_msg)
X{
X    dbref loc;
X    char buf[BUFFER_LEN];
X
X    if((loc = getloc(player)) == NOTHING) return 0;
X
X    if(!could_doit(player, thing)) {
X    /* can't do it */
X    if(db[thing].fail_message) {
X        notify(player, db[thing].fail_message);
X    } else if(default_fail_msg) {
X        notify(player, default_fail_msg);
X    }
X
X    if(db[thing].ofail) {
X        sprintf(buf, "%s %s", db[player].name, db[thing].ofail);
X        notify_except(db[loc].contents, player, buf);
X    }
X
X    return 0;
X    } else {
X    /* can do it */
X    if(db[thing].succ_message) {
X        notify(player, db[thing].succ_message);
X    }
X
X    if(db[thing].osuccess) {
X        sprintf(buf, "%s %s", db[player].name, db[thing].osuccess);
X        notify_except(db[loc].contents, player, buf);
X    }
X
X    return 1;
X    }
X}
X
Xint can_see(dbref player, dbref thing, int can_see_loc)
X{
X    if(player == thing || Typeof(thing) == TYPE_EXIT) {
X    return 0;
X    } else if(can_see_loc) {
X    return(!Dark(thing) || controls(player, thing));
X    } else {
X    /* can't see loc */
X    return(controls(player, thing));
X    }
X}
X
Xint controls(dbref who, dbref what)
X{
X    /* Wizard controls everything */
X    /* owners control their stuff */
X    return(what >= 0
X       && what < db_top
X       && (Wizard(who)
X           || who == db[what].owner));
X}
X
Xint can_link(dbref who, dbref what)
X{
X    return((Typeof(what) == TYPE_EXIT && db[what].location == NOTHING)
X       || controls(who, what));
X}
X
Xint payfor(dbref who, int cost)
X{
X    if(Wizard(who)) {
X    return 1;
X    } else if(db[who].pennies >= cost) {
X    db[who].pennies -= cost;
X    return 1;
X    } else {
X    return 0;
X    }
X}
X
Xint ok_name(const char *name)
X{
X    return (name
X        && *name
X        && *name != LOOKUP_TOKEN
X        && *name != NUMBER_TOKEN
X        && string_compare(name, "me")
X        && string_compare(name, "home")
X        && string_compare(name, "here"));
X}
X
Xint ok_player_name(const char *name)
X{
X    const char *scan;
X
X    if(!ok_name(name)) return 0;
X
X    for(scan = name; *scan; scan++) {
X    if(!isgraph(*scan)) {
X        return 0;
X    }
X    }
X
X    /* lookup name to avoid conflicts */
X    return (lookup_player(name) == NOTHING);
X}
END_OF_FILE
if test 2814 -ne `wc -c <'predicates.c'`; then
    echo shar: \"'predicates.c'\" unpacked with wrong size!
fi
# end of 'predicates.c'
fi
if test -f 'restart-cmu' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'restart-cmu'\"
else
echo shar: Extracting \"'restart-cmu'\" \(217 characters\)
sed "s/^X//" >'restart-cmu' <<'END_OF_FILE'
X#!/bin/csh -f
Xmv cmu.db cmu.db.old
Xif(-r cmu.db.new) then
X    mv cmu.db.new cmu.db
Xelse
X    cp cmu.db.old cmu.db
Xendif
X
Xcp netmud netmud.running
Xecho RESTARTED AT `date` >> cmu.log
Xexec netmud cmu.db cmu.db.new >>& cmu.log
END_OF_FILE
if test 217 -ne `wc -c <'restart-cmu'`; then
    echo shar: \"'restart-cmu'\" unpacked with wrong size!
fi
chmod +x 'restart-cmu'
# end of 'restart-cmu'
fi
if test -f 'sanity-check.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'sanity-check.c'\"
else
echo shar: Extracting \"'sanity-check.c'\" \(2547 characters\)
sed "s/^X//" >'sanity-check.c' <<'END_OF_FILE'
X#include "copyright.h"
X
X#include <stdio.h>
X
X#include "db.h"
X#include "config.h"
X
Xvoid check_exits(dbref i)
X{
X    dbref exit;
X    int count;
X
X    count = 10000;
X    for(exit = db[i].exits;
X    exit != NOTHING;
X    exit = db[exit].next) {
X    if(exit < 0 || exit >= db_top || Typeof(exit) != TYPE_EXIT) {
X        printf("%d has bad exit %d\n", i, exit);
X        break;
X    }
X
X    /* set type of exit to be really strange */
X    db[exit].flags = 4;    /* nonexistent type */
X
X    if(count-- < 0) {
X        printf("%d has looping exits\n");
X        break;
X    }
X    }
X}
X
Xvoid check_contents(dbref i)
X{
X    dbref thing;
X    dbref loc;
X    int count;
X
X    count = 10000;
X    for(thing = db[i].contents;
X    thing != NOTHING;
X    thing = db[thing].next) {
X    if(thing < 0 || thing >= db_top || Typeof(thing) == TYPE_ROOM) {
X        printf("%d contains bad object %d\n", i, thing);
X        break;
X    } else if((loc = db[thing].location) != i) {
X        printf("%d in %d but location is %d\n", thing, i, loc);
X    } else if(Typeof(thing) == TYPE_EXIT) {
X        db[thing].flags = 4; /* nonexistent type */
X    }
X    if(count-- < 0) {
X        printf("%d has looping contents\n");
X        break;
X    }
X    }
X}
X
Xvoid check_location(dbref i)
X{
X    dbref loc;
X
X    loc = db[i].location;
X    if(loc < 0 || loc >= db_top) {
X    printf("%d has bad loc %d\n", i, loc);
X    } else if(!member(i, db[loc].contents)) {
X    printf("%d not in loc %d\n", i, loc);
X    }
X}
X
Xvoid check_pennies(dbref i)
X{
X    dbref pennies;
X
X    pennies = db[i].pennies;
X
X    switch(Typeof(i)) {
X      case TYPE_ROOM:
X      case TYPE_EXIT:
X    break;
X      case TYPE_PLAYER:
X    if(pennies < 0 || pennies > MAX_PENNIES+100) {
X        printf("Player %s(%d) has %d pennies\n", db[i].name, i, pennies);
X    }
X    break;
X      case TYPE_THING:
X    if(pennies < 0 || pennies > MAX_OBJECT_ENDOWMENT) {
X        printf("Object %s(%d) endowed with %d pennies\n",
X           db[i].name, i, pennies);
X    }
X    break;
X    }
X}
X
Xvoid main(int argc, char **argv)
X{
X    dbref i;
X
X    if(db_read(stdin) < 0) {
X    puts("Database load failed!");
X    exit(1);
X    }
X
X    puts("Done loading database");
X
X    for(i = 0; i < db_top; i++) {
X    check_pennies(i);
X    switch(Typeof(i)) {
X      case TYPE_PLAYER:
X        check_contents(i);
X        check_location(i);
X        if(Wizard(i)) printf("Wizard: %s(%d)\n", db[i].name, i);
X        break;
X      case TYPE_THING:
X        check_location(i);
X        break;
X      case TYPE_ROOM:
X        check_contents(i);
X        check_exits(i);
X        break;
X    }
X    }
X
X    /* scan for unattached exits */
X    for(i = 0; i < db_top; i++) {
X    if(Typeof(i) == TYPE_EXIT) {
X        printf("Unattached exit %d\n", i);
X    }
X    }
X
X    exit(0);
X}
END_OF_FILE
if test 2547 -ne `wc -c <'sanity-check.c'`; then
    echo shar: \"'sanity-check.c'\" unpacked with wrong size!
fi
# end of 'sanity-check.c'
fi
if test -f 'small.db.README' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'small.db.README'\"
else
echo shar: Extracting \"'small.db.README'\" \(1371 characters\)
sed "s/^X//" >'small.db.README' <<'END_OF_FILE'
XNotes to new administrators using small.db:
X
X1. There are four objects of type player in small.db: Wizard(#1),
XBeaker(#2), guy(#121), and Darooha(#203).  As distributed, all have
Xthe password "potrzebie."  Wizard is the administrative player; it is
Xthe only one that has its WIZARD bit set, and it owns most of the core
Xrooms.  Beaker is included for testing.  guy and Darooha own the
X"Eastward Ho" and "Bud's" adventures; if you want to leave these
Xsamples out, you can remove them using extract.  Only the Wizard and
Xthe objects owned by the Wizard are really important...
X
X2. Small.db contains no unlinked exits; thus it will be impossible for
Xanybody who is not a WIZARD to connect new rooms to the core rooms.
XWhen TinyMUD was first started up on LANCELOT.AVALON.CS.CMU.EDU, the
XTown Square was given 9 unlinked exits (7 of the 8 cardinal directions
Xplus up and down) and was set to be LINK_OK; this allowed early
Xconstruction to take place in the neighborhood of the Town Square
Xwithout the need for administrative oversight.
X
XWhile this policy worked well during the early lifetime of the game,
Xas the database grew the immediate surroundings of the Town Square
Xbecame rather chaotic, and only a few of the directions exits from it
Xgot much use.  It might be reasonable to build a more extensive Town
XCenter before allowing haphazard construction.
X
X--Jim Aspnes
END_OF_FILE
if test 1371 -ne `wc -c <'small.db.README'`; then
    echo shar: \"'small.db.README'\" unpacked with wrong size!
fi
# end of 'small.db.README'
fi
if test -f 'stringutil.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'stringutil.c'\"
else
echo shar: Extracting \"'stringutil.c'\" \(868 characters\)
sed "s/^X//" >'stringutil.c' <<'END_OF_FILE'
X#include "copyright.h"
X
X/* String utilities */
X
X#include <ctype.h>
X
X#include "externs.h"
X
X#define DOWNCASE(x) (isupper(x) ? tolower(x) : (x))
X
Xint string_compare(const char *s1, const char *s2)
X{
X    while(*s1 && *s2 && DOWNCASE(*s1) == DOWNCASE(*s2)) s1++, s2++;
X
X    return(DOWNCASE(*s1) - DOWNCASE(*s2));
X}
X
Xint string_prefix(const char *string, const char *prefix)
X{
X    while(*string && *prefix && DOWNCASE(*string) == DOWNCASE(*prefix))
X    string++, prefix++;
X    return *prefix == '\0';
X}
X
X/* accepts only nonempty matches starting at the beginning of a word */
Xconst char *string_match(const char *src, const char *sub)
X{
X    if(*sub != '\0') {
X    while(*src) {
X        if(string_prefix(src, sub)) return src;
X        /* else scan to beginning of next word */
X        while(*src && isalnum(*src)) src++;
X        while(*src && !isalnum(*src)) src++;
X    }
X    }
X
X    return 0;
X}
X
END_OF_FILE
if test 868 -ne `wc -c <'stringutil.c'`; then
    echo shar: \"'stringutil.c'\" unpacked with wrong size!
fi
# end of 'stringutil.c'
fi
if test -f 'utils.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'utils.c'\"
else
echo shar: Extracting \"'utils.c'\" \(938 characters\)
sed "s/^X//" >'utils.c' <<'END_OF_FILE'
X#include "copyright.h"
X
X#include "db.h"
X
X/* remove the first occurence of what in list headed by first */
Xdbref remove_first(dbref first, dbref what)
X{
X    dbref prev;
X
X    /* special case if it's the first one */
X    if(first == what) {
X    return db[first].next;
X    } else {
X    /* have to find it */
X    DOLIST(prev, first) {
X        if(db[prev].next == what) {
X        db[prev].next = db[what].next;
X        return first;
X        }
X    }
X    return first;
X    }
X}
X
Xint member(dbref thing, dbref list)
X{
X    DOLIST(list, list) {
X    if(list == thing) return 1;
X    }
X
X    return 0;
X}
X
Xdbref reverse(dbref list)
X{
X    dbref newlist;
X    dbref rest;
X
X    newlist = NOTHING;
X    while(list != NOTHING) {
X    rest = db[list].next;
X    PUSH(list, newlist);
X    list = rest;
X    }
X    return newlist;
X}
X
Xconst char *getname(dbref loc)
X{
X    switch(loc) {
X      case NOTHING:
X    return "***NOTHING***";
X      case HOME:
X    return "***HOME***";
X      default:
X    return db[loc].name;
X    }
X}
X
END_OF_FILE
if test 938 -ne `wc -c <'utils.c'`; then
    echo shar: \"'utils.c'\" unpacked with wrong size!
fi
# end of 'utils.c'
fi
echo shar: End of archive 4 \(of 4\).
cp /dev/null ark4isdone
MISSING=""
for I in 1 2 3 4 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 4 archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0